//================异步============·
#include <iostream>
#include <future>
int main() 
{
    //把表达式封装成了任务
    std::packaged_task<int(int,int)> task([](int a,int b){
            return a + b;
            });
    std::future<int> myfuture = task.get_future();
    task(12,33); //执行任务
    std::cout << myfuture.get() <<std::endl; 
    return 0;
}

//#include <iostream>
//#include <thread>
//#include <future>
//void async_task(std::promise<int> prom) 
//{
//    //模拟异步操作
//    std::this_thread::sleep_for(std::chrono::seconds(1));
//    prom.set_value(42); //设置异步操作的结果
//}
//int main() 
//{
//    std::promise<int> prom; //生成了篮子，fut是夹子：
//    std::future<int> fut = prom.get_future(); //获取与promis关联的futue
//    std::thread t(async_task,std::move(prom));//启动异步任务，并将promis传递给它
//    //在主线程中等待异步操作的完成的结果
//    std::cout << "The relust is" <<fut.get() <<std::endl;
//    t.join();//等待线程结束
//    return 0;
//}

//#include <iostream>
//#include <thread>
//#include <future>
//int myfun(int a, int b) 
//{
//    std::cout << "this is myfunc" <<std::endl;
//    return a + b;
//}
//int main() 
//{
//    std::future<int> myf = std::async(myfun,10,20);
//    std::cout << "myf==" << myf.get() <<std::endl;
//    //std::thread t(myfun,10,20);
//    //t.join();
//    return 0;
//}
//=============死锁=============
//#include <iostream>
//#include <mutex>
//#include <thread>
//std::mutex mutex1;
//std::mutex mutex2;
//void task1() 
//{
//    std::lock_guard<std::mutex> mylock1(mutex1);
//    std::this_thread::sleep_for(std::chrono::milliseconds(100));
//    std::lock_guard<std::mutex> mylock2(mutex2);
//    std::cout << "Task 1 finished\n";
//}
//
//void task2() 
//{
//    std::lock_guard<std::mutex> mylock3(mutex2);
//    std::this_thread::sleep_for(std::chrono::milliseconds(100));//模拟工作
//    std::lock_guard<std::mutex> mylock4(mutex1);
//    std::cout << "Task 2 finished\n";
//}
//int main() 
//{
//    std::thread t1(task1);
//    std::thread t2(task1);
//    t1.join();
//    t2.join();
//    return 0;
//}
//==========原子变量和原子操作=============
//#include <iostream>
//#include <thread>
//#include <atomic> //引入原子变量头文件
//
////int num = 0; //我们不加锁，把这个变量申请为原子变量
//std::atomic<int> num(0);//num已经是一个原子变量了
//void addnum() 
//{
//    for(size_t i = 0; i< 1000000; ++i) 
//    {
//        //对后置前置++有运算符重载,保证了原子操作，但是没有对+这种操作有重载
//        num = num +1;//不是原子操作，尽管你这个变量是原子变量但是没有进行原子操作也不能保证线程安全
//        //对++ -- += -=都有原子操作
//    }
//}
//int main() 
//{
//    std::thread t1(addnum);
//    std::thread t2(addnum);
//    t1.join();
//    t2.join();
//    std::cout << num << std::endl;
//    return 0;
//}
//
//=================共享锁==================
//#include <iostream>
//#include <vector>
//#include <shared_mutex> //读写锁
//#include <thread>
//std::shared_mutex rw_mutex; //定义读写锁
//int shared_data = 0; //共享数据
////读线程函数
//void reader() 
//{
//    std::shared_laock lock(rw_mutex); //申请共享锁
//    std::cout << "Reader thread" << std::this_thread::get_id() << "reads vlue:"<<shared_data << std::endl;
//}
////写线程函数
//void writer(int value) 
//{
//    std::unique_lock lock(rw_mutex);//申请独占锁
//    shared_data = value;//修改共享数据
//    std::cout <<"writer thread " << std::this_thread::get_id() << "writes value" << shared_data << std::endl;
//}
//int main() 
//{
//    std::vector<std::thread> threads;// 用于存储线程的向量
//    //创建读线程
//    for(int i = 0; i < 5; ++i) 
//    {
//        threads.emplace_back(reader);//启动读线程并加入向量
//    }
//    //创建写线程
//    for(int i = 0; i< 5; ++i) 
//    {
//        threads.emplace_back(writer,i);
//    }
//    //等待所有线程完成
//    for(auto& mythread:threads) 
//    {
//        mythread.join();
//    }
//    return 0;
//}
//
//==================条件变量===================
//#include <iostream>
//#include <vector>
//#include <thread> //创建线程
//#include <mutex> //互斥锁
//#include <condition_variable> //条件变量
//std::mutex mtx; //互斥锁
//std::condition_variable cv; //条件变量
//bool flag = false; //共享变量，用于检测条件是不是成立
//
////根据共享变量组建逻辑，监测条件
//void myprint(int i)
//{
//    std::unique_lock<std::mutex> mylock(mtx);
//    while(!flag) 
//    {
//        std::cout <<"我是线程,我正在等待"<<std::endl;
//        cv.wait(mylock); //条件不成立，进入阻塞状态，释放掉锁，等待别人唤醒
//    }
//    std::cout <<std::this_thread::get_id() <<"-"<< i <<std::endl;
//}
//
//void updateflag() 
//{
//    std::unique_lock<std::mutex> mylock(mtx);
//    flag = true;
//    cv.notify_all();//通知所以的线程
//}
//int main() 
//{
//    //std::this_thread::sleep_for(3s);
//    std::vector<std::thread> mybox;
//    for(size_t i = 0; i < 10; ++i) 
//    {
//        mybox.emplace_back(myprint,i);
//    }
//    updateflag(); //更改这个值
//    for(auto& mythread:mybox) 
//    {
//        mythread.join();
//    }
//    return 0;
//}
